// app.js
import { request } from './utils/request'
import { storage } from './utils/storage'
import { auth } from './utils/auth'
import { logger } from './utils/logger'
import { config } from './config/index'

App({
  // 全局数据
  globalData: {
    userInfo: null,
    token: null,
    systemInfo: null,
    networkType: 'unknown',
    isConnected: true,
    appVersion: '1.0.0',
    apiVersion: 'v1',
    theme: 'light',
    language: 'zh_CN',
    location: null,
    scene: null,
    shareTicket: null,
    referrerInfo: null,
    updateManager: null,
    isFirstLaunch: true,
    launchTime: null,
    activeTime: null,
    backgroundTime: null,
    sessionId: null,
    deviceId: null
  },

  // 小程序初始化
  onLaunch(options) {
    console.log('小程序启动', options)
    
    this.globalData.scene = options.scene
    this.globalData.shareTicket = options.shareTicket
    this.globalData.referrerInfo = options.referrerInfo
    this.globalData.launchTime = Date.now()
    this.globalData.sessionId = this.generateSessionId()
    
    // 初始化配置
    this.initConfig()
    
    // 获取系统信息
    this.getSystemInfo()
    
    // 监听网络状态
    this.watchNetworkStatus()
    
    // 检查更新
    this.checkUpdate()
    
    // 初始化用户信息
    this.initUserInfo()
    
    // 统计启动
    this.trackLaunch(options)
    
    // 检查是否首次启动
    this.checkFirstLaunch()
    
    // 初始化位置信息
    this.initLocation()
    
    // 设置全局错误处理
    this.setupErrorHandler()
  },

  // 小程序显示
  onShow(options) {
    console.log('小程序显示', options)
    
    this.globalData.activeTime = Date.now()
    
    // 检查登录状态
    this.checkLoginStatus()
    
    // 统计显示
    this.trackShow(options)
    
    // 检查网络状态
    this.checkNetworkStatus()
    
    // 同步数据
    this.syncData()
  },

  // 小程序隐藏
  onHide() {
    console.log('小程序隐藏')
    
    this.globalData.backgroundTime = Date.now()
    
    // 统计隐藏
    this.trackHide()
    
    // 保存数据
    this.saveData()
  },

  // 小程序错误
  onError(error) {
    console.error('小程序错误', error)
    
    // 错误上报
    this.reportError(error)
    
    // 错误处理
    this.handleError(error)
  },

  // 页面不存在
  onPageNotFound(res) {
    console.warn('页面不存在', res)
    
    // 重定向到首页
    wx.reLaunch({
      url: '/pages/home/home'
    })
    
    // 统计404
    this.track404(res)
  },

  // 未处理的Promise拒绝
  onUnhandledRejection(res) {
    console.error('未处理的Promise拒绝', res)
    
    // 错误上报
    this.reportError(res.reason)
  },

  // 主题改变
  onThemeChange(res) {
    console.log('主题改变', res)
    
    this.globalData.theme = res.theme
    
    // 通知页面更新主题
    this.notifyThemeChange(res.theme)
  },

  // 初始化配置
  initConfig() {
    // 设置调试模式
    wx.setEnableDebug({
      enableDebug: config.debug
    })
    
    // 设置网络超时
    wx.setNetworkTimeout({
      request: config.networkTimeout.request,
      downloadFile: config.networkTimeout.downloadFile
    })
  },

  // 获取系统信息
  getSystemInfo() {
    try {
      const systemInfo = wx.getSystemInfoSync()
      this.globalData.systemInfo = systemInfo
      this.globalData.deviceId = this.generateDeviceId(systemInfo)
      
      console.log('系统信息', systemInfo)
    } catch (error) {
      console.error('获取系统信息失败', error)
    }
  },

  // 监听网络状态
  watchNetworkStatus() {
    // 获取当前网络状态
    wx.getNetworkType({
      success: (res) => {
        this.globalData.networkType = res.networkType
        this.globalData.isConnected = res.networkType !== 'none'
      }
    })
    
    // 监听网络状态变化
    wx.onNetworkStatusChange((res) => {
      this.globalData.networkType = res.networkType
      this.globalData.isConnected = res.isConnected
      
      console.log('网络状态变化', res)
      
      // 通知页面网络状态变化
      this.notifyNetworkChange(res)
      
      // 网络恢复时同步数据
      if (res.isConnected) {
        this.syncData()
      }
    })
  },

  // 检查更新
  checkUpdate() {
    if (wx.canIUse('getUpdateManager')) {
      const updateManager = wx.getUpdateManager()
      this.globalData.updateManager = updateManager
      
      updateManager.onCheckForUpdate((res) => {
        console.log('检查更新结果', res.hasUpdate)
      })
      
      updateManager.onUpdateReady(() => {
        wx.showModal({
          title: '更新提示',
          content: '新版本已经准备好，是否重启应用？',
          success: (res) => {
            if (res.confirm) {
              updateManager.applyUpdate()
            }
          }
        })
      })
      
      updateManager.onUpdateFailed(() => {
        wx.showModal({
          title: '更新失败',
          content: '新版本下载失败，请检查网络后重试',
          showCancel: false
        })
      })
    }
  },

  // 初始化用户信息
  async initUserInfo() {
    try {
      // 从缓存获取token
      const token = storage.get('token')
      if (token) {
        this.globalData.token = token
        
        // 验证token有效性
        const isValid = await auth.validateToken(token)
        if (isValid) {
          // 获取用户信息
          const userInfo = await this.getUserInfo()
          this.globalData.userInfo = userInfo
        } else {
          // token无效，清除缓存
          this.clearUserInfo()
        }
      }
    } catch (error) {
      console.error('初始化用户信息失败', error)
    }
  },

  // 获取用户信息
  async getUserInfo() {
    try {
      const response = await request({
        url: '/user/info',
        method: 'GET'
      })
      return response.data
    } catch (error) {
      console.error('获取用户信息失败', error)
      throw error
    }
  },

  // 清除用户信息
  clearUserInfo() {
    this.globalData.userInfo = null
    this.globalData.token = null
    storage.remove('token')
    storage.remove('userInfo')
  },

  // 检查登录状态
  checkLoginStatus() {
    if (!this.globalData.token) {
      return false
    }
    
    // 检查token是否过期
    const isExpired = auth.isTokenExpired(this.globalData.token)
    if (isExpired) {
      this.clearUserInfo()
      return false
    }
    
    return true
  },

  // 检查网络状态
  checkNetworkStatus() {
    if (!this.globalData.isConnected) {
      wx.showToast({
        title: '网络连接异常',
        icon: 'none',
        duration: 2000
      })
    }
  },

  // 同步数据
  async syncData() {
    if (!this.globalData.isConnected || !this.globalData.token) {
      return
    }
    
    try {
      // 同步用户数据
      await this.syncUserData()
      
      // 同步学习进度
      await this.syncStudyProgress()
      
      // 同步离线数据
      await this.syncOfflineData()
    } catch (error) {
      console.error('数据同步失败', error)
    }
  },

  // 同步用户数据
  async syncUserData() {
    try {
      const userInfo = await this.getUserInfo()
      this.globalData.userInfo = userInfo
      storage.set('userInfo', userInfo)
    } catch (error) {
      console.error('同步用户数据失败', error)
    }
  },

  // 同步学习进度
  async syncStudyProgress() {
    try {
      const progress = storage.get('studyProgress') || []
      if (progress.length > 0) {
        await request({
          url: '/study/sync-progress',
          method: 'POST',
          data: { progress }
        })
        
        // 清除本地进度
        storage.remove('studyProgress')
      }
    } catch (error) {
      console.error('同步学习进度失败', error)
    }
  },

  // 同步离线数据
  async syncOfflineData() {
    try {
      const offlineData = storage.get('offlineData') || []
      if (offlineData.length > 0) {
        await request({
          url: '/data/sync-offline',
          method: 'POST',
          data: { data: offlineData }
        })
        
        // 清除离线数据
        storage.remove('offlineData')
      }
    } catch (error) {
      console.error('同步离线数据失败', error)
    }
  },

  // 保存数据
  saveData() {
    try {
      // 保存用户信息
      if (this.globalData.userInfo) {
        storage.set('userInfo', this.globalData.userInfo)
      }
      
      // 保存应用状态
      storage.set('appState', {
        theme: this.globalData.theme,
        language: this.globalData.language,
        lastActiveTime: this.globalData.activeTime
      })
    } catch (error) {
      console.error('保存数据失败', error)
    }
  },

  // 检查首次启动
  checkFirstLaunch() {
    const hasLaunched = storage.get('hasLaunched')
    if (!hasLaunched) {
      this.globalData.isFirstLaunch = true
      storage.set('hasLaunched', true)
      
      // 首次启动引导
      this.showWelcomeGuide()
    } else {
      this.globalData.isFirstLaunch = false
    }
  },

  // 显示欢迎引导
  showWelcomeGuide() {
    // 可以在这里显示引导页面或弹窗
    console.log('显示欢迎引导')
  },

  // 初始化位置信息
  initLocation() {
    wx.getLocation({
      type: 'gcj02',
      success: (res) => {
        this.globalData.location = {
          latitude: res.latitude,
          longitude: res.longitude,
          accuracy: res.accuracy
        }
        console.log('位置信息', this.globalData.location)
      },
      fail: (error) => {
        console.warn('获取位置信息失败', error)
      }
    })
  },

  // 设置全局错误处理
  setupErrorHandler() {
    // 监听未捕获的错误
    wx.onError((error) => {
      this.reportError(error)
    })
    
    // 监听未处理的Promise拒绝
    wx.onUnhandledRejection((res) => {
      this.reportError(res.reason)
    })
  },

  // 错误上报
  reportError(error) {
    try {
      logger.error('应用错误', {
        error: error.toString(),
        stack: error.stack,
        userAgent: this.globalData.systemInfo?.system,
        timestamp: Date.now(),
        userId: this.globalData.userInfo?.id,
        sessionId: this.globalData.sessionId
      })
    } catch (e) {
      console.error('错误上报失败', e)
    }
  },

  // 错误处理
  handleError(error) {
    // 显示友好的错误提示
    wx.showToast({
      title: '系统异常，请稍后重试',
      icon: 'none',
      duration: 2000
    })
  },

  // 统计启动
  trackLaunch(options) {
    logger.track('app_launch', {
      scene: options.scene,
      path: options.path,
      query: options.query,
      shareTicket: options.shareTicket,
      referrerInfo: options.referrerInfo,
      timestamp: this.globalData.launchTime
    })
  },

  // 统计显示
  trackShow(options) {
    logger.track('app_show', {
      scene: options.scene,
      path: options.path,
      query: options.query,
      timestamp: this.globalData.activeTime
    })
  },

  // 统计隐藏
  trackHide() {
    const duration = this.globalData.backgroundTime - this.globalData.activeTime
    logger.track('app_hide', {
      duration,
      timestamp: this.globalData.backgroundTime
    })
  },

  // 统计404
  track404(res) {
    logger.track('page_not_found', {
      path: res.path,
      query: res.query,
      isEntryPage: res.isEntryPage,
      timestamp: Date.now()
    })
  },

  // 通知主题变化
  notifyThemeChange(theme) {
    // 可以通过事件总线通知页面
    console.log('通知主题变化', theme)
  },

  // 通知网络变化
  notifyNetworkChange(status) {
    // 可以通过事件总线通知页面
    console.log('通知网络变化', status)
  },

  // 生成会话ID
  generateSessionId() {
    return 'session_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9)
  },

  // 生成设备ID
  generateDeviceId(systemInfo) {
    const { brand, model, system, platform } = systemInfo
    const deviceString = `${brand}_${model}_${system}_${platform}`
    return 'device_' + this.hashCode(deviceString)
  },

  // 简单哈希函数
  hashCode(str) {
    let hash = 0
    if (str.length === 0) return hash
    for (let i = 0; i < str.length; i++) {
      const char = str.charCodeAt(i)
      hash = ((hash << 5) - hash) + char
      hash = hash & hash // 转换为32位整数
    }
    return Math.abs(hash).toString(36)
  },

  // 工具方法：获取用户信息
  getUserData() {
    return this.globalData.userInfo
  },

  // 工具方法：设置用户信息
  setUserData(userInfo) {
    this.globalData.userInfo = userInfo
    storage.set('userInfo', userInfo)
  },

  // 工具方法：获取token
  getToken() {
    return this.globalData.token
  },

  // 工具方法：设置token
  setToken(token) {
    this.globalData.token = token
    storage.set('token', token)
  },

  // 工具方法：检查是否登录
  isLoggedIn() {
    return !!this.globalData.token && !!this.globalData.userInfo
  },

  // 工具方法：登出
  logout() {
    this.clearUserInfo()
    
    // 跳转到登录页
    wx.reLaunch({
      url: '/pages/login/login'
    })
  },

  // 工具方法：获取系统信息
  getSystemData() {
    return this.globalData.systemInfo
  },

  // 工具方法：检查网络连接
  isNetworkConnected() {
    return this.globalData.isConnected
  },

  // 工具方法：获取当前主题
  getCurrentTheme() {
    return this.globalData.theme
  },

  // 工具方法：切换主题
  switchTheme(theme) {
    this.globalData.theme = theme
    storage.set('theme', theme)
    this.notifyThemeChange(theme)
  }
})